package com.im.util;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.im.service.dto.MabRuntimeException;

import java.lang.reflect.Field;
import java.util.*;

/**
 * List处理工具类
 * 
 * @author Administrator
 * 
 */
public class ListUtil {

    private static final Logger logger = LogManager.getLogger(ListUtil.class);

	/**
	 * 移除list中重复的对象
	 * <p>
	 * List中的对象必须依据hashCode的协定正确重写hashCode及equals方法
	 * 
	 * @param <T>
	 * @param list
	 */
	public static <T> void removeDuplicate(List<T> list) {
		Set<T> set = new HashSet<T>(list);
		list.clear();
		list.addAll(set);
	}

	/**
	 * 根据比较字段对List中的对象进行排序
	 * 
	 * @param <T>
	 * @param list
	 * @param orderByFields
	 *            比较字段
	 * @param isSortedByDesc
	 *            排序方式,true为降序,false为升序
	 */
	private static <T> void sort(List<T> list, final String[] orderByFields,
			final boolean isSortedByDesc) {
		if (list == null || list.size() == 0) {
			return;
		}
		Comparator<T> comparator = new Comparator<T>() {
			public int compare(T o1, T o2) {
				boolean isMap = false;
				if (orderByFields != null && orderByFields.length > 0) {
					Class<?> cls = o1.getClass();
					if (o1 instanceof Map<?, ?>) {
						// 比较对象为Map
						isMap = true;
					} else {
						// 比较对象为JavaBean
						isMap = false;
					}
					// 比较对象为JavaBean
					for (String field : orderByFields) {
						try {
							Object v1, v2;
							if (isMap) {
								if (!((Map<?, ?>) o1).containsKey(field)
										|| !((Map<?, ?>) o2).containsKey(field)) {
									// 不存在字段,则抛异常
									throw new Exception("对象中不存在比较字段！");
								}
								v1 = ((Map<?, ?>) o1).get(field);
								v2 = ((Map<?, ?>) o2).get(field);
							} else {
								Field f1 = cls.getDeclaredField(field);
								f1.setAccessible(true);
								Field f2 = cls.getDeclaredField(field);
								f2.setAccessible(true);
								v1 = f1.get(o1);
								v2 = f2.get(o2);
							}
							if (v1 == null && v2 == null) {
								// 两个字段值都为空,表示相等,继续比较下一个字段
								continue;
							} else if (v1 == null && v2 != null) {
								// 第一个字段值为空,第二个字段值不为空,返回比较结果大于0(v1 > v2)
								if (isSortedByDesc) {
									return -1;
								} else {
									return 1;
								}
							} else if (v1 != null && v2 == null) {
								// 第一个字段值不为空,第二个字段值为空,返回比较结果小于0(v1 < v2)
								if (isSortedByDesc) {
									return 1;
								} else {
									return -1;
								}
							} else {
								// 字段值都转换为字符串进行比较
								int compareResult = 0; 
								if(v1 instanceof Date){
								   compareResult =((Date)v1).compareTo((Date)v2);	
								}else{
								   compareResult =v1.toString().compareTo(v2.toString());
							    }
								if (compareResult == 0) {
									// 两个字段值相等,继续比较下一个字段
									continue;
								} else {
									// 排序方式为降序,对比较结果取反
									if (isSortedByDesc) {
										compareResult = 0 - compareResult;
									}
									// 两个字段值不相等,返回比较结果
									return compareResult;
								}
							}
						} catch (Exception e) {
							logger.error("List排序异常,该排序字段不存在:{},异常信息:{}", e);
							throw new MabRuntimeException(Result.BSS_SYS_ERROR,
									"List排序异常,该排序字段不存在:" + field, e);
						}
					}
				} else {
					// 没有比较字段,两个对象认为是相等的
					return 0;
				}
				// 前面都没返回,最后认为对象是相等的
				return 0;
			}
		};
		Collections.sort(list, comparator);
	}

	/**
	 * 根据比较字段对List中的对象以升序方式进行排序
	 * 
	 * @param <T>
	 * @param list
	 * @param orderByFields
	 *            比较字段
	 */
	public static <T> void sortByAsc(List<T> list, String[] orderByFields) {
		sort(list, orderByFields, false);
	}

	/**
	 * 根据比较字段对List中的对象以降序方式进行排序
	 * 
	 * @param <T>
	 * @param list
	 * @param orderByFields
	 */
	public static <T> void sortByDesc(List<T> list, String[] orderByFields) {
		sort(list, orderByFields, true);
	}

	/**
	 * 根据比较字段对List中的对象以升序方式进行排序，并移除重复对象
	 * 
	 * @param <T>
	 * @param list
	 * @param orderByFields
	 */
	public static <T> void removeDuplicateAndSortByAsc(List<T> list,
			String[] orderByFields) {
		removeDuplicate(list);
		sort(list, orderByFields, false);
	}

	/**
	 * 根据比较字段对List中的对象以降序方式进行排序，并移除重复对象
	 * 
	 * @param <T>
	 * @param list
	 * @param orderByFields
	 */
	public static <T> void removeDuplicateAndSortByDesc(List<T> list,
			String[] orderByFields) {
		removeDuplicate(list);
		sort(list, orderByFields, true);
	}
	
	/**
	 * 判断List是否为null或者空
	 * 
	 * @param list
	 * @return
	 */
	public static boolean isListEmpty(List<?> list) {
		return list == null || list.isEmpty();
	}
	
	/**
	 * 判断map是否为null或者空
	 * 
	 * @param map
	 * @return
	 */
	public static boolean isMapEmpty(Map<?, ?> map) {
		return map == null || map.isEmpty();
	}
	
}